from functools import lru_cache

# imports
import pytest  # used for our unit tests
from workload import _joined_number_str

# unit tests

# ------------------------------
# BASIC TEST CASES
# ------------------------------

def test_zero_returns_empty_string():
    # Test that n=0 returns an empty string (no numbers to join)
    codeflash_output = _joined_number_str(0) # 2.02μs -> 441ns (359% faster)

def test_one_returns_zero():
    # Test that n=1 returns just "0"
    codeflash_output = _joined_number_str(1) # 2.34μs -> 430ns (445% faster)

def test_two_returns_zero_one():
    # Test that n=2 returns "0 1"
    codeflash_output = _joined_number_str(2) # 2.48μs -> 411ns (505% faster)

def test_small_n():
    # Test a small n for correct sequence
    codeflash_output = _joined_number_str(5) # 2.69μs -> 411ns (553% faster)

def test_typical_n():
    # Test a typical n value for correct sequence
    codeflash_output = _joined_number_str(10) # 3.25μs -> 381ns (754% faster)

# ------------------------------
# EDGE TEST CASES
# ------------------------------

def test_negative_n_raises():
    # Negative n should raise ValueError or produce an empty string (by Python's range behavior)
    # Here, range(-5) is empty, so result should be empty string
    codeflash_output = _joined_number_str(-5) # 1.85μs -> 1.67μs (10.8% faster)

def test_large_single_digit_boundary():
    # Test n=10, which is the boundary between single and double digit numbers
    codeflash_output = _joined_number_str(10) # 3.30μs -> 401ns (722% faster)

def test_double_digit_boundary():
    # Test n=100, which includes both single and double digit numbers
    codeflash_output = _joined_number_str(100); result = codeflash_output # 11.4μs -> 371ns (2970% faster)

def test_non_integer_input_raises():
    # Test that non-integer input raises TypeError
    with pytest.raises(TypeError):
        _joined_number_str(3.5)
    with pytest.raises(TypeError):
        _joined_number_str("10")
    with pytest.raises(TypeError):
        _joined_number_str(None)

def test_large_n_boundary():
    # Test n=999, which is the largest n that can be cached (due to lru_cache maxsize=1001)
    codeflash_output = _joined_number_str(999); result = codeflash_output # 93.2μs -> 511ns (18135% faster)

def test_n_is_maxsize_plus_one():
    # Test n=1001, which is just above the lru_cache maxsize (should still work)
    codeflash_output = _joined_number_str(1001); result = codeflash_output # 87.0μs -> 100μs (13.1% slower)

# ------------------------------
# LARGE SCALE TEST CASES
# ------------------------------

def test_large_scale_500():
    # Test with n=500 (large, but under 1000)
    codeflash_output = _joined_number_str(500); result = codeflash_output # 45.2μs -> 431ns (10381% faster)

def test_large_scale_999():
    # Test with n=999 (upper bound for single cache entry)
    codeflash_output = _joined_number_str(999); result = codeflash_output # 86.7μs -> 501ns (17210% faster)

def test_large_scale_1000():
    # Test with n=1000 (edge of large scale)
    codeflash_output = _joined_number_str(1000); result = codeflash_output # 86.3μs -> 411ns (20908% faster)

def test_large_scale_performance():
    # Test that calling the function multiple times with large n is fast due to caching
    import time
    n = 900
    start = time.time()
    for _ in range(10):
        codeflash_output = _joined_number_str(n); s = codeflash_output
    elapsed = time.time() - start

# ------------------------------
# ADDITIONAL EDGE CASES
# ------------------------------

def test_n_is_two_digit_string():
    # Passing a string that looks like a number should raise TypeError
    with pytest.raises(TypeError):
        _joined_number_str("42")

def test_n_is_bool():
    # Passing a boolean should treat True as 1 and False as 0
    # This is Python's default behavior, but let's check it
    codeflash_output = _joined_number_str(True) # 2.48μs -> 691ns (258% faster)
    codeflash_output = _joined_number_str(False) # 1.22μs -> 451ns (171% faster)

def test_n_is_very_large():
    # Test with n=999 (very large, but within allowed)
    codeflash_output = _joined_number_str(999); result = codeflash_output # 88.6μs -> 501ns (17582% faster)

def test_n_is_none():
    # Passing None should raise TypeError
    with pytest.raises(TypeError):
        _joined_number_str(None)

def test_n_is_float_integer_value():
    # Passing a float that is an integer value should raise TypeError
    with pytest.raises(TypeError):
        _joined_number_str(10.0)

def test_result_is_str():
    # Ensure the result is always a string
    for n in [0, 1, 10, 100, 500]:
        pass

def test_cache_behavior():
    # Ensure that repeated calls with same n return the same object (due to lru_cache)
    codeflash_output = _joined_number_str(25); s1 = codeflash_output # 4.89μs -> 451ns (984% faster)
    codeflash_output = _joined_number_str(25); s2 = codeflash_output # 211ns -> 181ns (16.6% faster)

def test_mutation_detection():
    # If the function returns numbers in wrong order, test should fail
    # This is a mutation test: check that the result is exactly as expected for n=5
    codeflash_output = _joined_number_str(5) # 2.79μs -> 401ns (597% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.